Systems and methods for contrastive learning of visual representations

ABSTRACT

Provided are systems and methods for contrastive learning of visual representations. In particular, the present disclosure provides systems and methods that leverage particular data augmentation schemes and a learnable nonlinear transformation between the representation and the contrastive loss to provide improved visual representations. In contrast to certain existing techniques, the contrastive self-supervised learning algorithms described herein do not require specialized architectures or a memory bank. Some example implementations of the proposed approaches can be referred to as a simple framework for contrastive learning of representations or “SimCLR.” Further example aspects are described below and provide the following benefits and insights.

FIELD

The present disclosure relates generally to systems and methods for contrastive learning of visual representations. More particularly, the present disclosure relates to contrastive learning frameworks that leverage data augmentation and a learnable nonlinear transformation between the representation and the contrastive loss to provide improved visual representations.

BACKGROUND

Learning effective visual representations without human supervision is a long-standing problem. Most mainstream approaches fall into one of two classes: generative or discriminative. Generative approaches learn to generate or otherwise model pixels in the input space. However, pixel-level generation is computationally expensive and may not be necessary for representation learning. Discriminative approaches learn representations using objective functions similar to those used for supervised learning, but train networks to perform pretext tasks where both the inputs and labels are derived from an unlabeled dataset. Many such approaches have relied on heuristics to design pretext tasks. These heuristics often limit the generality of the learned representations.

For example, many existing approaches define contrastive prediction tasks by changing the architecture of the model to be learned. As examples, Hjelm et al. (2018) and Bachman et al. (2019) achieve global-to-local view prediction via constraining the receptive field in the network architecture, whereas Oord et al. (2018) and Hénaff et al. (2019) achieve neighboring view prediction via a fixed image splitting procedure and a context aggregation network. However, these custom architectures add additional complexity and reduce the flexibility and/or applicability of the resulting model.

SUMMARY

Aspects and advantages of embodiments of the present disclosure will be set forth in part in the following description, or can be learned from the description, or can be learned through practice of the embodiments.

One example aspect of the present disclosure is directed to a computing system to perform contrastive learning of visual representations. The computing system includes one or more processors and one or more non-transitory computer-readable media that collectively store: a base encoder neural network configured to process an input image to generate an intermediate representation of the input image; a projection head neural network configured to process the intermediate representation of the input image to generate a projected representation of the input image, wherein to generate the projected representation, the projection head neural network is configured to perform at least one non-linear transformation; and instructions that, when executed by the one or more processors, cause the computing system to perform operations. The operations include: obtaining a training image; performing a plurality of first augmentation operations on the training image to obtain a first augmented image, wherein the plurality of first augmentation operations comprise at least a first random crop operation that randomly crops the training image and a first random color distortion operation that randomly modifies color values of the training image to the training image; separate from performing the plurality of first augmentation operations, performing a plurality of second augmentation operations on the training image to obtain a second augmented image, wherein the plurality of second augmentation operations comprise at least a second random crop operation that randomly crops the training image and a second random color distortion operation that randomly modifies color values of the training image; respectively processing, with the base encoder neural network, the first augmented image and the second augmented image to respectively generate a first intermediate representation for the first augmented image and a second intermediate representation for the second augmented image; respectively processing, with the projection head neural network, the first intermediate representation and the second intermediate representation to respectively obtain a first projected representation for the first augmented image and a second projected representation for the second augmented image; evaluating a loss function that evaluates a difference between the first projected representation and the second projected representation; and modifying one or more values of one or more parameters of one or both of the base encoder neural network and the projection head neural network based at least in part on the loss function.

Another example aspect of the present disclosure is directed to a computer-implemented method to perform contrastive learning of visual representations. The method includes: obtaining a training image; performing a plurality of first augmentation operations on the training image to obtain a first augmented image, wherein the plurality of first augmentation operations comprise at least a first random crop operation that randomly crops the training image and a first random color distortion operation that randomly modifies color values of the training image to the training image; separate from performing the plurality of first augmentation operations, performing a plurality of second augmentation operations on the training image to obtain a second augmented image, wherein the plurality of second augmentation operations comprise at least a second random crop operation that randomly crops the training image and a second random color distortion operation that randomly modifies color values of the training image; respectively processing, with a base encoder neural network, the first augmented image and the second augmented image to respectively generate a first intermediate representation for the first augmented image and a second intermediate representation for the second augmented image; respectively processing, with a projection head neural network, the first intermediate representation and the second intermediate representation to respectively generate a first projected representation for the first augmented image and a second projected representation for the second augmented image; evaluating a loss function that evaluates a difference between the first projected representation and the second projected representation; and modifying one or more values of one or more parameters of one or both of the base encoder neural network and the projection head neural network based at least in part on the loss function.

Another example aspect of the present disclosure is directed to one or more non-transitory computer-readable media that collectively store a base encoder neural network that has been trained by a training method. The training method includes: obtaining a training image; performing a plurality of first augmentation operations on the training image to obtain a first augmented image, wherein the plurality of first augmentation operations comprise at least a first random crop operation that randomly crops the training image and a first random color distortion operation that randomly modifies color values of the training image to the training image; separate from performing the plurality of first augmentation operations, performing a plurality of second augmentation operations on the training image to obtain a second augmented image, wherein the plurality of second augmentation operations comprise at least a second random crop operation that randomly crops the training image and a second random color distortion operation that randomly modifies color values of the training image; respectively processing, with the base encoder neural network, the first augmented image and the second augmented image to respectively generate a first intermediate representation for the first augmented image and a second intermediate representation for the second augmented image; respectively processing, with a projection head neural network, the first intermediate representation and the second intermediate representation to respectively generate a first projected representation for the first augmented image and a second projected representation for the second augmented image; evaluating a loss function that evaluates a difference between the first projected representation and the second projected representation; and modifying one or more values of one or more parameters of the base encoder neural network based at least in part on the loss function.

Other aspects of the present disclosure are directed to various systems, apparatuses, non-transitory computer-readable media, user interfaces, and electronic devices.

These and other features, aspects, and advantages of various embodiments of the present disclosure will become better understood with reference to the following description and appended claims. The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate example embodiments of the present disclosure and, together with the description, serve to explain the related principles.

BRIEF DESCRIPTION OF THE DRAWINGS

Detailed discussion of embodiments directed to one of ordinary skill in the art is set forth in the specification, which makes reference to the appended figures, in which:

FIG. 1 depicts an example plot of accuracy of different linear classifiers trained on representations learned via different techniques including example embodiments of the present disclosure.

FIG. 2A depicts a graphical diagram of a framework for contrastive learning according to example embodiments of the present disclosure.

FIG. 2B depicts a graphical diagram of an example use of a base encoder neural network trained according to example frameworks according to example embodiments of the present disclosure.

FIGS. 3A and 3B depict graphical diagrams of example random cropping outcomes on example images according to example embodiments of the present disclosure.

FIG. 4 provides example results of example data augmentation operations according to example embodiments of the present disclosure.

FIG. 5 provides example performance measurements for various data augmentation compositions according to example embodiments of the present disclosure.

FIGS. 6A and 6B provide histograms that show the effect of example color distortion augmentation operations according to example embodiments of the present disclosure.

FIG. 7 provides linear evaluation results for example models with varied depth and width according to example embodiments of the present disclosure.

FIG. 8 provides linear evaluation results for example models with different projection heads according to example embodiments of the present disclosure.

FIG. 9 provides example negative loss functions and their gradients according to example embodiments of the present disclosure.

FIG. 10 provides linear evaluation results for example models with different batch size and number of epochs according to example embodiments of the present disclosure.

FIG. 11A depicts a block diagram of an example computing system according to example embodiments of the present disclosure.

FIG. 11B depicts a block diagram of an example computing device according to example embodiments of the present disclosure.

FIG. 11C depicts a block diagram of an example computing device according to example embodiments of the present disclosure.

Reference numerals that are repeated across plural figures are intended to identify the same features in various implementations.

DETAILED DESCRIPTION Overview

Example aspects of the present disclosure are directed to systems and methods for contrastive learning of visual representations. In particular, the present disclosure provides systems and methods that leverage particular data augmentation schemes and a learnable nonlinear transformation between the representation and the contrastive loss to provide improved visual representations. In contrast to certain existing techniques, the contrastive self-supervised learning algorithms described herein do not require specialized architectures or a memory bank. Some example implementations of the proposed approaches can be referred to as a simple framework for contrastive learning of representations or “SimCLR.” Further example aspects are described below and provide the following benefits and insights.

One example aspect of the present disclosure is directed to particular compositions of data augmentations which enable the system to define effective predictive tasks. Composition of multiple data augmentation operations is crucial in defining the contrastive prediction tasks that yield effective representations. As one example, a combination of random crop and color distortions provides particular benefit. In addition, unsupervised contrastive learning benefits from stronger data augmentation than supervised learning.

Another example aspect is directed to model frameworks which include a learnable nonlinear transformation between the representation and the contrastive loss. Introducing a learnable nonlinear transformation between the representation and the contrastive loss substantially improves the quality of the learned representations which may be due, at least in part, to preventing information loss in the representation.

According to another example aspect, specific embodiments are identified and evaluated in which contrastive learning benefits from larger batch sizes and more training steps, for example, as compared to supervised learning. As one example, representation learning with contrastive cross entropy loss benefits from normalized embeddings and an appropriately adjusted temperature parameter. Like supervised learning, contrastive learning also benefits from deeper and wider networks.

Example implementations of the proposed systems are then empirically shown to considerably outperform previous methods for self-supervised and semi-supervised learning on ImageNet. In particular, a linear classifier trained on self-supervised representations learned by example implementations of the proposed systems and methods achieves 76.5% top-1 accuracy, which is a 7% relative improvement over previous state-of-the-art, matching the performance of a supervised ResNet-50. As one example, FIG. 1 illustrates ImageNet Top-1 accuracy of linear classifiers trained on representations learned with different self-supervised methods (pretrained on ImageNet). The gray cross indicates supervised ResNet-50. Example implementations of the proposed method referred to as SimCLR are shown in bold. Further, when fine-tuned on only 1% of the labels, example implementations of the proposed techniques achieve 85.8% top-5 accuracy, outperforming AlexNet with 100 fewer labels. When fine-tuned on other natural image classification datasets, SimCLR performs on par with or better than a strong supervised baseline on 10 out of 12 datasets.

Thus, the present disclosure provides a simple framework and its instantiation for contrastive visual representation learning. Its components are carefully studied and the effects of different design choices are demonstrated. By combining these findings, the proposed systems and methods improve considerably over previous methods for self-supervised, semi-supervised, and transfer learning. Specifically, the discussion and results contained herein demonstrate that the complexity of some previous methods for self-supervised learning is not necessary to achieve good performance.

The systems and methods of the present disclosure provide a number of technical effects and benefits. As one example, the contrastive learning techniques described herein can result in models which generate improved visual representations. These visual representations can then be used to make more accurate downstream decisions (e.g., more accurate object detections, classifications, segmentations, etc.). Thus, the techniques described herein result in improved performance of a computer vision system.

As another example technical effect and benefit, and in contrast to various existing approaches, the contrastive learning techniques described herein do not require use of a memory bank. By obviating the need for a dedicated memory bank, the proposed techniques can reduce memory load, thereby conserving computing resources such as memory resources.

As another example technical effect and benefit, and in contrast to various existing approaches, the contrastive learning techniques described herein do not require specialized, custom, or otherwise unduly complex model architectures to enable contrastive learning. By obviating the need for complex architectures, more simplified architectures can be used, resulting in models which run faster (e.g., reduced latency) and consume fewer computing resources (e.g., reduced usage of processors, memory, network bandwidth, etc.)

With reference now to the Figures, example embodiments of the present disclosure will be discussed in further detail.

Example Contrastive Learning Techniques

Example Contrastive Learning Framework

Example implementations of the present disclosure learn representations by maximizing agreement between differently augmented views of the same data example via a contrastive loss in the latent space. As illustrated in FIG. 2A, an example framework 200 can include the following four major components:

A stochastic data augmentation module (shown generally at 203) that transforms any given data example (e.g., an input image x shown at 202) randomly resulting in two correlated views of the same example, denoted {tilde over (x)}_(i) and {tilde over (x)}_(j), which are shown at 212 and 222, respectively. These augmented images 212 and 22 can be considered as a positive pair. Although the present disclosure focuses on data examples from the image domain for ease of explanation, the framework is extensible to data examples of different domains as well which are susceptible to augmentation of some kind, including text and/or audio domains. Example types of images that can be used include video frames, LiDAR point clouds, computed tomography scans, X-ray images, hyper-spectral images, and/or various other forms of imagery.

In some example implementations, three augmentations can be applied at 203: random cropping followed by resize back to the original size, random color distortions, and random Gaussian blur. As shown in the following sections, the combination of random crop and color distortion significantly assists in providing a good performance. However, various other combinations of augmentations can be performed.

A base encoder neural network 204 (represented in notation herein as f(⋅) that extracts intermediate representation vectors from augmented data examples. For example, in the illustration of FIG. 2A, the base encoder neural network 204 has generated intermediate representations 214 and 224 from augmented images 212 and 222, respectively. The example framework 200 allows various choices of the network architecture without any constraints. Some example implementations opt for simplicity and adopt the ResNet architecture (He et al., 2016) to obtain h_(i)=f({tilde over (x)}_(i))=ResNet({tilde over (x)}_(j)) where h_(i)∈

^(d) is the output after the average pooling layer.

A projection head neural network 206 (represented in the notation herein as g(⋅)) that maps the intermediate representations to final representations within the space where contrastive loss is applied. For example, the projection head neural network 206 has generated final representations 216 and 226 from the intermediate representations 214 and 224, respectively. In some example implementations of the present disclosure, the projection head neural network 206 can be a multi-layer perceptron with one hidden layer to obtain z_(i)=g(h_(i))=W⁽²⁾σ(W⁽¹⁾h) where σ is a ReLU non-linearity. As shown in the following sections, it is beneficial to define the contrastive loss on final representations z_(i)'s rather than intermediate representations h_(i)'s.

A contrastive loss function can be defined for a contrastive prediction task. As one example, given a set {{tilde over (x)}_(k)} including a positive pair of examples {tilde over (x)}_(i) 212 and {tilde over (x)}_(j) 222, the contrastive prediction task aims to identify {tilde over (x)}_(j) in {{tilde over (x)}_(k)}_(k=i) for a given {tilde over (x)}_(i), e.g., based on similarly between their respective final representations 216 and 226.

In some implementations, to perform training within the illustrated framework, a minibatch of N examples can be randomly sampled and the contrastive prediction task can be defined on pairs of augmented examples derived from the minibatch, resulting in 2N data points. In some implementations, negative examples are not explicitly sampled. Instead, given a positive pair, the other 2(N−1) augmented examples within a minibatch can be treated as negative examples. Let sim(u,v)=u^(T)v/∥u∥∥v∥ denote the cosine similarity between two vectors u and v. Then one example loss function for a positive pair of examples (i,j) can be defined as

$\begin{matrix} {{\ell_{i,j} = {{- \log}\frac{\exp\;\left( {{sim}\;{\left( {z_{i},z_{j}} \right)/\tau}} \right.}{\underset{k = 1}{\sum\limits^{2N}}{{11}_{\lbrack{k \neq i}\rbrack}{\exp\left( {{{sim}\left( {z_{i},z_{j}} \right)}/\tau} \right.}}}}},} & (1) \end{matrix}$ where k≠i∈{0,1} is an indicator function evaluating to 1 iff k≠i and τ denotes a temperature parameter. The final loss can be computed across all positive pairs, both (i,j) and (j,i), in a minibatch. For convenience, this loss is referred to further herein as NT-Xent (the normalized temperature-scaled cross entropy loss).

The below example Algorithm 1 summarizes one example implementation of the proposed method:

Algorithm 1—Example Learning Algorithm

input: batch size N, temperature constant τ, structure of f, g, T.

for sampled minibatch {x_(k)}_(k=1) ^(N) do

for all k∈{1, . . . , N} do

-   -   draw two augmentation functions t˜T, t′˜T     -   #the first augmentation     -   {tilde over (x)}_(2k-1)=t(x_(k))     -   h_(2k-1)=f({tilde over (x)}_(2k-1)) #representation     -   z_(2k-1)=g(h_(2k-1)) #projection     -   #the second augmentation     -   {tilde over (x)}_(2k)=t′(x_(k))     -   h_(2k)=f({tilde over (x)}_(2k)) #representation     -   z_(2k)=g(h_(2k)) #projection

end for

for all i∈{1, . . . , 2N} and j∈{1, . . . , 2N} do

-   -   s_(i,j)=z_(i) ^(T)z_(j)/∥z_(i)∥∥z_(j)∥) #pairwise similarity

end for

define l(i,j) as

${\ell\left( {i,j} \right)} = {{- \log}\frac{\exp\left( s_{i,j} \right)}{\underset{k = 1}{\sum\limits^{2N}}{{11}_{\lbrack{k \neq i}\rbrack}{\exp\left( s_{i,k} \right)}}}}$

$\mathcal{L} = {\frac{1}{2N}{\overset{N}{\sum\limits_{k = 1}}\left\lbrack {{\ell\left( {{{2k} - 1},{2k}} \right)} + {\ell\left( {{2k},{{2k} - 1}} \right)}} \right\rbrack}}$

update networks f and g to minimize L:

end for

return encoder network f(⋅), and optionally throw away g(⋅)

FIG. 2B depicts a graphical diagram of an example use of a base encoder neural network trained after it has been trained in the example framework shown in FIG. 2A. In particular, the base encoder neural network 204 has been extracted and an additional task specific model 250 has been appended to the base encoder neural network 204. For example, the task specific model 250 can be any kind of model including linear models or non-linear models such as neural networks.

The task specific model 250 and/or the base encoder neural network 204 can be additionally trained (e.g., “fine-tuned”) on additional training data (e.g., which may be task specific data). The additional training can be, for example, supervised learning training.

After fine-tuning, an additional input 252 can be provided to the base encoder neural network 204 which can produce an intermediate representation 254. The task-specific model 250 can receive and process the intermediate representation 254 to generate a task-specific prediction 256. As examples, the task-specific prediction 256 can be a classification prediction; a detection prediction; a recognition prediction; a segmentation prediction; and/or other prediction tasks.

Example Training with Large Batch Size

Example implementations of the present disclosure enable training of the model without use of a memory bank. Instead, in some implementations, the training batch size N can be varied from 256 to 8192. A batch size of 8192 provides 16382 negative examples per positive pair from both augmentation views. Training with large batch size may be unstable when using standard SGD/Momentum with linear learning rate scaling. To stabilize the training, the LARS optimizer (You et al. 2017) can be used for all batch sizes. In some implementations, the model can be trained with Cloud TPUs, using 32 to 128 cores depending on the batch size.

Global BN. Standard ResNets use batch normalization. In distributed training with data parallelism, the BN mean and variance are typically aggregated locally per device. In some example implementations of contrastive learning techniques described herein, as positive pairs are computed in the same device, the model can exploit the local information leakage to improve prediction accuracy without improving representations. For example, this issue can be addressed by aggregating BN mean and variance over all devices during the training. Other approaches include shuffling data examples or replacing BN with layer norm.

Example Evaluation Protocol

This subsection describes the protocol for example empirical studies described herein, which aim to understand different design choices in the proposed framework.

Example Dataset and Metrics. Most of the example studies for unsupervised pretraining (learning encoder network f without labels) are done using the ImageNet ILSVRC-2012 dataset (Rusakovsky et al, 2015). The pretrained results are also tested on a wide range of datasets for transfer learning. To evaluate the learned representations, a linear evaluation protocol is followed where a linear classifier is trained on top of the frozen base network, and test accuracy is used as a proxy for representation quality. Beyond linear evaluation, comparisons are also made against state-of-the-art on semi-supervised and transfer learning.

Example Default Setting. Unless otherwise specified, for data augmentation in the example empirical experiments described herein, random crop and resize (with random flip), color distortions, and Gaussian blur are used; a ResNet-50 is used as the base encoder network; and a 2-layer MLP projection head is used to project the representation to a 128-dimensional latent space. As the loss, NT-Xent is used, optimized using LARS with linear learning rate scaling (i.e. LearningRate=0.3×BatchSize/256) and weight decay of 10⁻⁶. Training is performed at batch size 4096 for 100 epochs. Furthermore, linear warmup is used for the first 10 epochs and the learning rate is decayed with the cosine decay schedule without restarts.

Example Data Augmentation Techniques for Contrastive Representation Learning

Data augmentation defines predictive tasks. Data augmentation has not been considered as a systematic way to define the contrastive prediction task. Many existing approaches define contrastive prediction tasks by changing the architecture Hjelm et al. (2018) and Bachman et al. (2019) achieve global-to-local view prediction via constraining the receptive field in the network architecture, whereas Oord et al. (2018) and Hénaff et al. (2019) achieve neighboring view prediction via a fixed image splitting procedure and a context aggregation network. However, these custom architectures add additional complexity and reduce the flexibility and/or applicability of the resulting model.

The techniques described herein can avoid this complexity by performing simple random cropping (with resizing) of target images, which creates a family of predictive tasks subsuming the above mentioned existing approaches. FIGS. 3A and 3B demonstrate this principle. FIG. 3A shows global and local views while FIG. 3B shows adjacent views. Specifically, solid rectangles are images, dashed rectangles are random crops. By randomly cropping images, the proposed systems can sample contrastive prediction tasks that include global to local view (B→A) or adjacent view (D→C) prediction.

This simple design choice conveniently decouples the predictive task from other components such as the neural network architecture. Broader contrastive prediction tasks can be defined by extending the family of augmentations and composing them stochastically.

Composition of Data Augmentation Operations is Crucial for Learning Good Representations

To systematically study the impact of data augmentation, several different augmentations were considered and can optionally be included in implementations of the present disclosure. One example type of augmentation involves spatial/geometric transformation of data, such as cropping and resizing (with horizontal flipping), rotation, and cutout. Another example type of augmentation involves appearance transformation, such as color distortion (including color dropping, brightness, contrast, saturation, hue), Gaussian blur, and Sobel filtering. FIG. 4 visualizes the augmentations were considered and can optionally be included in implementations of the present disclosure, which include the following examples visualized relative to the original image: crop and resize; crop, resize (and flip); color distortion (drop); color distortion (jitter); rotate; cutout; Gaussian noise; Gaussian blur; and Sobel filtering.

To understand the effects of individual data augmentations and the importance of augmentation composition, the performance of the proposed framework was evaluated when applying augmentations individually or in pairs. Since ImageNet images are of different sizes, example implementations used for evaluation consistently apply crop and resize images, which makes it difficult to study other augmentations in the absence of cropping. To eliminate this confound, an asymmetric data transformation setting was considered for this ablation. Specifically, the example implementations always first randomly crop images and resize them to the same resolution, and then apply the targeted transformation(s) only to one branch of the framework in FIG. 2A, while leaving the other branch as the identity (i.e. t(x_(i))=x_(i)). Note that this asymmetric data augmentation hurts the performance. Nonetheless, this setup should not substantively change the impact of individual data augmentations or their compositions.

FIG. 5 shows linear evaluation results under individual and composition of transformations. In particular, FIG. 5 shows linear evaluation (ImageNet top-1 accuracy) under individual or composition of data augmentations, applied only to one branch. For all columns by the last, diagonal entries correspond to single transformation, and off-diagonals correspond to composition of two transformations (applied sequentially). The last column reflects the average over the row.

It can be observed from FIG. 5 that no single transformation suffices to learn excellent representations, even though the model can almost perfectly identify the positive pairs in the contrastive task. When composing augmentations, the contrastive prediction task becomes harder, but the quality of representation improves dramatically.

One composition of augmentations stands out: random cropping and random color distortion. One explanation is as follows: one serious issue when using only random cropping as data augmentation is that most patches from an image share a similar color distribution. FIGS. 6A and 6B shows that color histograms alone suffice to distinguish images. Neural nets may exploit this shortcut to solve the predictive task. Therefore, it is important to compose cropping with color distortion in order to learn generalizable features.

Specifically, FIGS. 6A and 6B show histograms of pixel intensities (over all channels) for different crops of two different images (i.e., two rows). FIG. 6A is without color distortion. FIG. 6B is with color distortion. The image for the first row is from FIG. 4. All axes have the same range.

Contrastive Learning Benefits from Stronger Data Augmentation than Supervised Learning

To further demonstrate the importance of the color augmentation, the strength of color augmentation as adjusted as shown in Table 1. Stronger color augmentation substantially improves the linear evaluation of the learned unsupervised models. In this context, AutoAugment (Cubuk et al., 2019), a sophisticated augmentation policy found using supervised learning, does not work better than simple cropping+(stronger) color distortion. When training supervised models with the same set of augmentations, it was observed that stronger color augmentation does not improve or even hurts their performance. Thus, these experiments show that unsupervised contrastive learning benefits from stronger (color) data augmentation than supervised learning. As such, data augmentation that does not yield accuracy benefits for supervised learning can still help considerably with contrastive learning.

Color distortion strength Methods ⅛ ¼ ½ 1 1 (+Blur) AutoAug SimCLR 59.6 61.0 62.6 63.2 64.5 61.1 Supervised 77.0 76.7 76.5 75.7 75.4 77.1

Table 1: Top-1 accuracy of unsupervised ResNet-50 using linear evaluation and supervised ResNet-50, under varied color distortion strength and other data transformations. Strength 1 (+Blur) is one example default data augmentation policy.

Example Data Augmentation Details

Some example options for performing data augmentation operations are provided. Other options or details can be used additionally or alternatively to these specific example details.

Example Random Crop and Resize to 224×224: A crop of random size (uniform from 0.08 to 1.0 in area) of the original size and a random aspect ratio (default: of 3/4 to 4/3) of the original aspect ratio is made. This crop is resized to the original size. In some implementations, the random crop (with resize) is followed by a random horizontal/left-to-right flip with some probability (e.g., 50%). This is helpful but not essential. By removing this from the example default augmentation policy, the top-1 linear evaluation drops from 64.5% to 63.4% for our ResNet-50 model trained in 100 epochs.

Example Color Distortion Color distortion is composed by color jittering and color dropping. Stronger color jittering usually helps, so a strength parameter can be used. One example pseudo-code for an example color distortion operation using TensorFlow is as follows.

import tensorflow as tf

def color_distortion(image, s=1.0):

#image is a tensor with value range in [0, 1].

#s is the strength of color distortion.

def color_jitter(x):

#one can also shuffle the order of following augmentations

#each time they are applied.

x=tf.image.random_brightness(x, max_delta=0.8*s)

x=tf.image.random_contrast(x, lower=1-0.8*s, upper=1+0.8*s)

x=tf.image.random_saturation(x, lower=1-0.8*s, upper=1+0.8*s)

x=tf.image.random_hue(x, max delta=0.2*s)

x=tf.clip_by_value(x, 0, 1)

return x

def color_drop(x):

image=tf.image.rgb_to_grayscale(image)

image=tf.tile(image, [1, 1, 3])

#randomly apply transformation with probability p.

image=random_apply(color_jitter, image, p=0.8)

image=random_apply(color_drop, image, p=0.2)

return image

One example pseudo-code for an example color distortion operation using Pytorch is as follows.

from torchvision import transforms

def get_color_distortion (s=1.0):

#s is the strength of color distortion.

color_jitter=transforms.ColorJitter (0.8*s, 0.8*s, 0.8*s, 0.2*s)

rnd_color_jitter=transforms.RandomApply ([color_jitter], p=0.8)

rnd_gray=transforms.RandomGrayscale (p=0.2)

color_distort=transforms.Compose ([

-   -   rnd_color_jitter,     -   rnd_gray])

return color_distort

Example Gaussian blur This augmentation is helpful, as it improves the ResNet-50 trained for 100 epochs from 63.2% to 64.5%. The image can be blurred with some probability (e.g., 50% of the time) using a Gaussian kernel. A random sample a E [0.1,2.0] can be obtained, and the kernel size can be set to be some percentage (e.g., 10%) of the image height/width.

Example Architectures for the Base Encoder and the Projection Head

Unsupervised Contrastive Learning Benefits (More) from Bigger Models

FIG. 7 shows that increasing depth and width both improve performance. While similar findings hold for supervised learning, the gap between supervised models and linear classifiers trained on unsupervised models shrinks as the model size increases, suggesting that unsupervised learning benefits more from bigger models than its supervised counterpart.

Specifically, FIG. 7 shows linear evaluation of models with varied depth and width. Models in blue dots are example implementations of the present disclosure trained for 100 epochs, models in red starts are example implementations of the present disclosure trained for 1000 epochs, and models in green crosses are supervised ResNets trained for 90 epochs. Training longer does not improve supervised ResNets.

A Nonlinear Projection Head Improves the Representation Quality of the Layer Before it

Another example aspect evaluates the importance of including a projection head, i.e. h). FIG. 8 shows linear evaluation results using three different architectures for the head: (1) identity mapping; (2) linear projection; and (3) the default nonlinear projection with one additional hidden layer (and ReLU activation). Specifically, FIG. 8 shows linear evaluation of representations with different projection heads g and various dimensions of z=g(h). The representation h (before projection) is 2048-dimensional here.

It can be observed that a nonlinear projection is better than a linear projection (+3%), and much better than no projection (>10%). When a projection head is used, similar results are observed regardless of output dimension. Furthermore, even when nonlinear projection is used, the layer before the projection head, h, is still much better (>10%) than the layer after, z=g(h), which shows that the hidden layer before the projection head is a better representation than the layer after.

One explanation of this phenomenon is that the importance of using the representation before the nonlinear projection is due to loss of information induced by the contrastive loss. In particular, z=g(h) is trained to be invariant to data transformation. Thus, g can remove information that may be useful for the downstream task, such as the color or orientation of objects. By leveraging the nonlinear transformation g(⋅) more information can be formed and maintained in h. To verify this hypothesis, experiments were conducted that use either h or g(h) to learn to predict the transformation applied during the pretraining. Here it was set g(h)=W⁽²⁾σ(W⁽¹⁾h), with the same input and output dimensionality (i.e. 2048). Table 2 shows h contains much more information about the transformation applied, while g(h) loses information.

Representation What to predict? Random guess h g(h) Color vs grayscale 80 99.3 97.4 Rotation 25 67.6 25.6 Orig. vs corrupted 50 99.5 59.6 Orig. vs Sobel filtered 50 96.6 56.3

Table 2 shows the accuracy of training additional MLPs on different representations to predict the transformation applied. Other than crop and color augmentation, rotation (one of {0,90,180,270}), Gaussian noise, and Sobel filtering transformation were additionally and independently added during the pretraining for the last three rows. Both h and g(h) are of the same dimensionality, i.e. 2048.

Example Loss Functions and Batch Size

Normalized Cross Entropy Loss with Adjustable Temperature Works Better than Alternatives

Additional example experiments compared the NT-Xent loss against other commonly used contrastive loss functions, such as logistic loss (Mikolov et al., 2013), and margin loss (Schroff et al., 2015). FIG. 9 shows the objective function as well as the gradient to the input of the loss function. Specifically, FIG. 9 shows negative loss functions and their gradients. All input vectors i.e. u, v⁺, v⁻, are l₂ normalized. NT-Xent is an abbreviation for “Normalized Temperature-scaled Cross Entropy”. Different loss functions impose different weightings of positive and negative examples.

Looking at the gradient, it can be observed that: 1) l₂ normalization along with temperature effectively weights different examples, and an appropriate temperature can help the model learn from hard negatives; and 2) unlike cross-entropy, other objective functions do not weigh the negatives by their relative hardness. As a result, one must apply semi-hard negative mining (Schroff et al., 2015) for these loss functions: instead of computing the gradient over all loss terms, one can compute the gradient using semi-hard negative terms (i.e., those that are within the loss margin and closest in distance, but farther than positive examples).

To make the comparisons fair, the same l₂ normalization was used for all loss functions, and we tune the hyperparameters, and report their best results. Table 3 shows that, while (semi-hard) negative mining helps, the best result is still much worse than NT-Xent loss.

Margin NT-Logi. Margin (sh) NT-Logi.(sh) NT-Xent 50.9 51.6 57.5 57.9 63.9

Table 3: Linear evaluation (top-1) for models trained with different loss functions. “sh” means using semi-hard negative mining.

Another example set of experiments tested the importance of the l₂ normalization and temperature τ in the NT-Xent loss. Table 4 shows that without normalization and proper temperature scaling, performance is significantly worse. Without l₂ normalization, the contrastive task accuracy is higher, but the resulting representation is worse under linear evaluation.

l₂ norm? τ Entropy Contrastive acc. Top 1 Yes 0.05 1.0 90.5 59.7 0.1 4.5 87.8 64.4 0.5 8.2 68.2 60.7 1 8.3 59.1 58.0 No 10 0.5 91.7 57.2 100 0.5 2.1 57.0

Table 4: Linear evaluation for models trained with different choices of l₂ norm and temperature τ for NT-Xent loss. The contrastive distribution is over 4096 examples.

Contrastive Learning Benefits (More) from Larger Batch Sizes and Longer Training

FIG. 10 shows the impact of batch size when models are trained for different numbers of epochs. In particular, FIG. 10 provides data for linear evaluation models (ResNet-50) trained with different batch size and epochs. Each bar is a single run from scratch.

When the number of training epochs is small (e.g. 100 epochs), larger batch sizes have a significant advantage over the smaller ones. With more training steps/epochs, the gaps between different batch sizes decrease or disappear, provided the batches are randomly resampled. In contrast to supervised learning, in contrastive learning, larger batch sizes provide more negative examples, facilitating convergence (i.e. taking fewer epochs and steps for a given accuracy). Training longer also provides more negative examples, improving the results.

Comparison with State-of-the-Art

In this section, example experiments are described in which ResNet-50 is used in 3 different hidden layer widths (width multipliers of 1×, 2×, and 4×). For better convergence, the models here are trained for 1000 epochs.

Linear evaluation. Table 5 compares example results with previous approaches (Zhuang et al., 2019; He et al., 2019a; Misra & van der Maaten, 2019; Hénaff et al., 2019; Kolesnikov et al., 2019; Donahue & Simonyan, 2019; Bachman et al., 2019; Tian et al., 2019) in the linear evaluation setting. FIG. 1 also shows comparisons among different methods. Standard networks are able to be used to obtain substantially better results compared to previous methods that require specifically designed architectures. The best result obtained with the proposed ResNet-50 (4×) can match the supervised pretrained ResNet-50.

Method Architecture Param. Top 1 Top 5 Methods using ResNet-50: Local Agg. ResNet-50 24 60.2 — MoCo ResNet-50 24 60.6 — PIRL ResNet-50 24 63.6 — CPC v2 ResNet-50 24 63.8 85.3 SimCLR (ours) ResNet-50 24 69.3 89.0 Methods using other architectures: Rotation RevNet-50 (4×) 86 55.4 — BigBiGAN RevNet-50 (4×) 86 61.3 81.9 AMDIM Custom-ResNet 626 68.1 — CMC ResNet-50 (2×) 188 68.4 88.2 MoCo ResNet-50 (4×) 375 68.6 — CPC v2 ResNet-161 (*) 305 71.5 90.1 SimCLR (ours) ResNet-50 (2×) 94 74.2 92.0 SimCLR (ours) ResNet-50 (4×) 375 76.5 93.2

Table 5: ImageNet accuracies of linear classifiers trained on representations learned with different self-supervised methods.

Semi-supervised learning. In some examples, 1% or 10% of the labeled ILSVRC-12 training datasets can be sampled in a class-balanced way (i.e. around 12.8 and 128 images per class respectively). The whole base network can be finetined on the labeled data without regularization. Table 6 shows the comparisons of the results against recent methods (Zhai et al., 2019; Xie et al., 2019; Sohn et al., 2020; Wu et al., 2018; Donahue & Simonyan, 2019; Misra & van der Maaten, 2019; Hénaff et al., 2019). Again, the proposed approach significantly improves over state-of-the-art with both 1% and 10% of the labels.

Label fraction 1% 10% Method Architecture Top 5 Methods using other label-propagation: Pseudo-label ResNet50 51.6 82.4 VAT + Entropy Min. ResNet50 47.0 83.4 UDA (w. RandAug) ResNet50 — 88.5 FixMatch (w. ResNet50 — 89.1 RandAug) S4L (Rot + VAT + En. ResNet50 (4×) — 91.2 M.) Methods using representation learning only: InstDisc ResNet50 39.2 77.4 BigBiGAN RevNet-50 (4×) 55.2 78.8 PIRL ResNet-50 57.2 83.8 CPC v2 ResNet-161 (*) 77.9 91.2 SimCLR (ours) ResNet-50 75.5 87.8 SimCLR (ours) ResNet-50 (2×) 83.0 91.2 SimCLR (ours) ResNet-50 (4×) 85.8 92.6

Table 6: ImageNet accuracy of models trained with few labels.

Transfer learning. Transfer learning performance was also evaluated across 12 natural image datasets in both linear evaluation (fixed feature extractor) and fine-tuning settings. Hyperparameter tuning was performed for each model-dataset combination and the best hyperparameters on a validation set were selected. Table 8 shows results with the ResNet-50 (4×) model. When fine-tuned, the proposed self-supervised model significantly outperforms the supervised baseline on 5 datasets, whereas the supervised baseline is superior on only 2 (i.e. Pets and Flowers). On the remaining 5 datasets, the models are statistically tied.

Food CIFAR10 CIFAR100 Birdsnap SUN397 Cars Aircraft VOC2007 DTD Pets Caltech-101 Flowers Linear evaluation: SimCLR 76.9 95.3 80.2 48.4 65.9 60.0 61.2 84.2 78.9 89.2 93.9 95.0 (ours) Supervised 75.2 95.7 81.2 56.4 64.9 68.8 63.8 83.8 78.7 92.3 94.1 94.2 Fine-tuned: SimCLR 89.4 98.6 89.0 78.2 68.1 92.1 87.0 86.6 77.8 92.1 94.1 97.6 (ours) Supervised 88.7 98.3 88.7 77.8 67.0 91.4 88.0 86.5 78.8 93.2 94.2 98.0 Random 88.3 96.0 81.9 77.0 53.7 91.3 84.8 69.4 64.1 82.7 72.5 92.5 init

Table 7: Comparison of transfer learning performance of our self-supervised approach with supervised baselines across 12 natural image classification datasets, for ResNet-50 (4×) models pretrained on ImageNet. Results not significantly worse than the best (p >0.05, permutation test) are shown in bold.

Example Devices and Systems

FIG. 11A depicts a block diagram of an example computing system 100 according to example embodiments of the present disclosure. The system 100 includes a user computing device 102, a server computing system 130, and a training computing system 150 that are communicatively coupled over a network 180.

The user computing device 102 can be any type of computing device, such as, for example, a personal computing device (e.g., laptop or desktop), a mobile computing device (e.g., smartphone or tablet), a gaming console or controller, a wearable computing device, an embedded computing device, or any other type of computing device.

The user computing device 102 includes one or more processors 112 and a memory 114. The one or more processors 112 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, a FPGA, a controller, a microcontroller, etc.) and can be one processor or a plurality of processors that are operatively connected. The memory 114 can include one or more non-transitory computer-readable storage mediums, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory 114 can store data 116 and instructions 118 which are executed by the processor 112 to cause the user computing device 102 to perform operations.

In some implementations, the user computing device 102 can store or include one or more machine-learned models 120. For example, the machine-learned models 120 can be or can otherwise include various machine-learned models such as neural networks (e.g., deep neural networks) or other types of machine-learned models, including non-linear models and/or linear models. Neural networks can include feed-forward neural networks, recurrent neural networks (e.g., long short-term memory recurrent neural networks), convolutional neural networks or other forms of neural networks. Example machine-learned models 120 are discussed with reference to FIGS. 2A-B.

In some implementations, the one or more machine-learned models 120 can be received from the server computing system 130 over network 180, stored in the user computing device memory 114, and then used or otherwise implemented by the one or more processors 112. In some implementations, the user computing device 102 can implement multiple parallel instances of a single machine-learned model 120.

Additionally or alternatively, one or more machine-learned models 140 can be included in or otherwise stored and implemented by the server computing system 130 that communicates with the user computing device 102 according to a client-server relationship. For example, the machine-learned models 140 can be implemented by the server computing system 140 as a portion of a web service (e.g., a visual analysis service). Thus, one or more models 120 can be stored and implemented at the user computing device 102 and/or one or more models 140 can be stored and implemented at the server computing system 130.

The user computing device 102 can also include one or more user input component 122 that receives user input. For example, the user input component 122 can be a touch-sensitive component (e.g., a touch-sensitive display screen or a touch pad) that is sensitive to the touch of a user input object (e.g., a finger or a stylus). The touch-sensitive component can serve to implement a virtual keyboard. Other example user input components include a microphone, a traditional keyboard, or other means by which a user can provide user input.

The server computing system 130 includes one or more processors 132 and a memory 134. The one or more processors 132 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, a FPGA, a controller, a microcontroller, etc.) and can be one processor or a plurality of processors that are operatively connected. The memory 134 can include one or more non-transitory computer-readable storage mediums, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory 134 can store data 136 and instructions 138 which are executed by the processor 132 to cause the server computing system 130 to perform operations.

In some implementations, the server computing system 130 includes or is otherwise implemented by one or more server computing devices. In instances in which the server computing system 130 includes plural server computing devices, such server computing devices can operate according to sequential computing architectures, parallel computing architectures, or some combination thereof.

As described above, the server computing system 130 can store or otherwise include one or more machine-learned models 140. For example, the models 140 can be or can otherwise include various machine-learned models. Example machine-learned models include neural networks or other multi-layer non-linear models. Example neural networks include feed forward neural networks, deep neural networks, recurrent neural networks, and convolutional neural networks. Example models 140 are discussed with reference to FIGS. 2A-B.

The user computing device 102 and/or the server computing system 130 can train the models 120 and/or 140 via interaction with the training computing system 150 that is communicatively coupled over the network 180. The training computing system 150 can be separate from the server computing system 130 or can be a portion of the server computing system 130.

The training computing system 150 includes one or more processors 152 and a memory 154. The one or more processors 152 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, a FPGA, a controller, a microcontroller, etc.) and can be one processor or a plurality of processors that are operatively connected. The memory 154 can include one or more non-transitory computer-readable storage mediums, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory 154 can store data 156 and instructions 158 which are executed by the processor 152 to cause the training computing system 150 to perform operations. In some implementations, the training computing system 150 includes or is otherwise implemented by one or more server computing devices.

The training computing system 150 can include a model trainer 160 that trains the machine-learned models 120 and/or 140 stored at the user computing device 102 and/or the server computing system 130 using various training or learning techniques, such as, for example, backwards propagation of errors. For example, a loss function can be backpropagated through the model(s) to update one or more parameters of the model(s) (e.g., based on a gradient of the loss function). Various loss functions can be used such as mean squared error, likelihood loss, cross entropy loss, hinge loss, and/or various other loss functions such as those contained in FIG. 9. Gradient descent techniques can be used to iteratively update the parameters over a number of training iterations.

In some implementations, performing backwards propagation of errors can include performing truncated backpropagation through time. The model trainer 160 can perform a number of generalization techniques (e.g., weight decays, dropouts, etc.) to improve the generalization capability of the models being trained.

In particular, the model trainer 160 can train the machine-learned models 120 and/or 140 based on a set of training data 162. The training data 162 can include, for example, data of different modalities such as imagery, audio samples, text, and/or the like. Example types of images that can be used include video frames, LiDAR point clouds, X-ray images, computed tomography scans, hyper-spectral images, and/or various other forms of imagery.

In some implementations, if the user has provided consent, the training examples can be provided by the user computing device 102. Thus, in such implementations, the model 120 provided to the user computing device 102 can be trained by the training computing system 150 on user-specific data received from the user computing device 102. In some instances, this process can be referred to as personalizing the model.

The model trainer 160 includes computer logic utilized to provide desired functionality. The model trainer 160 can be implemented in hardware, firmware, and/or software controlling a general purpose processor. For example, in some implementations, the model trainer 160 includes program files stored on a storage device, loaded into a memory and executed by one or more processors. In other implementations, the model trainer 160 includes one or more sets of computer-executable instructions that are stored in a tangible computer-readable storage medium such as RAM hard disk or optical or magnetic media. The model trainer can be configured to perform any of the contrastive learning techniques described herein.

The network 180 can be any type of communications network, such as a local area network (e.g., intranet), wide area network (e.g., Internet), or some combination thereof and can include any number of wired or wireless links. In general, communication over the network 180 can be carried via any type of wired and/or wireless connection, using a wide variety of communication protocols (e.g., TCP/IP, HTTP, SMTP, FTP), encodings or formats (e.g., HTML, XML), and/or protection schemes (e.g., VPN, secure HTTP, SSL).

FIG. 11A illustrates one example computing system that can be used to implement the present disclosure. Other computing systems can be used as well. For example, in some implementations, the user computing device 102 can include the model trainer 160 and the training dataset 162. In such implementations, the models 120 can be both trained and used locally at the user computing device 102. In some of such implementations, the user computing device 102 can implement the model trainer 160 to personalize the models 120 based on user-specific data.

FIG. 11B depicts a block diagram of an example computing device 10 that performs according to example embodiments of the present disclosure. The computing device 10 can be a user computing device or a server computing device.

The computing device 10 includes a number of applications (e.g., applications 1 through N). Each application contains its own machine learning library and machine-learned model(s). For example, each application can include a machine-learned model. Example applications include a text messaging application, an email application, a dictation application, a virtual keyboard application, a browser application, etc.

As illustrated in FIG. 11B, each application can communicate with a number of other components of the computing device, such as, for example, one or more sensors, a context manager, a device state component, and/or additional components. In some implementations, each application can communicate with each device component using an API (e.g., a public API). In some implementations, the API used by each application is specific to that application.

FIG. 11C depicts a block diagram of an example computing device 50 that performs according to example embodiments of the present disclosure. The computing device 50 can be a user computing device or a server computing device.

The computing device 50 includes a number of applications (e.g., applications 1 through N). Each application is in communication with a central intelligence layer. Example applications include a text messaging application, an email application, a dictation application, a virtual keyboard application, a browser application, etc. In some implementations, each application can communicate with the central intelligence layer (and model(s) stored therein) using an API (e.g., a common API across all applications).

The central intelligence layer includes a number of machine-learned models. For example, as illustrated in FIG. 11C, a respective machine-learned model (e.g., a model) can be provided for each application and managed by the central intelligence layer. In other implementations, two or more applications can share a single machine-learned model. For example, in some implementations, the central intelligence layer can provide a single model (e.g., a single model) for all of the applications. In some implementations, the central intelligence layer is included within or otherwise implemented by an operating system of the computing device 50.

The central intelligence layer can communicate with a central device data layer. The central device data layer can be a centralized repository of data for the computing device 50. As illustrated in FIG. 11C, the central device data layer can communicate with a number of other components of the computing device, such as, for example, one or more sensors, a context manager, a device state component, and/or additional components. In some implementations, the central device data layer can communicate with each device component using an API (e.g., a private API).

Additional Disclosure

The technology discussed herein makes reference to servers, databases, software applications, and other computer-based systems, as well as actions taken and information sent to and from such systems. The inherent flexibility of computer-based systems allows for a great variety of possible configurations, combinations, and divisions of tasks and functionality between and among components. For instance, processes discussed herein can be implemented using a single device or component or multiple devices or components working in combination. Databases and applications can be implemented on a single system or distributed across multiple systems. Distributed components can operate sequentially or in parallel.

While the present subject matter has been described in detail with respect to various specific example embodiments thereof, each example is provided by way of explanation, not limitation of the disclosure. Those skilled in the art, upon attaining an understanding of the foregoing, can readily produce alterations to, variations of, and equivalents to such embodiments. Accordingly, the subject disclosure does not preclude inclusion of such modifications, variations and/or additions to the present subject matter as would be readily apparent to one of ordinary skill in the art. For instance, features illustrated or described as part of one embodiment can be used with another embodiment to yield a still further embodiment. Thus, it is intended that the present disclosure cover such alterations, variations, and equivalents.

EXAMPLE REFERENCES

-   Abadi, M., Barham, P., Chen, J., Chen, Z., Davis, A., Dean, J., . .     . others. (2016). Tensorflow: A system for large-scale machine     learning. 12th {USENIX} Symposium on Operating Systems Design and     Implementation ({OSDI} 16), (pp. 265-283). -   Arora, S., Khandeparkar, H., Khodak, M., Plevrakis, O., &     Saunshi, N. (2019). A theoretical analysis of contrastive     unsupervised representation learning. arXiv preprint     arXiv:1902.09229. -   Bachman, P., Hjelm, R. D., & Buchwalter, W. (2019). Learning     representations by maximizing mutual information across views.     Advances in Neural Information Processing Systems, (pp.     15509-15519). -   Becker, S., & Hinton, G. E. (1992). Self-organizing neural network     that discovers surfaces in random-dot stereograms. Nature, 355,     161-163. -   Berg, T., Liu, J., Lee, S. W., Alexander, M. L., Jacobs, D. W., &     Belhumeur, P. N. (2014). Birdsnap: Large-scale fine-grained visual     categorization of birds. IEEE Conference on Computer Vision and     Pattern Recognition (CVPR), (pp. 2019-2026). -   Berthelot, D., Carlini, N., Goodfellow, I., Papernot, N., Oliver,     A., & Raffel, C. A. (2019). Mixmatch: A holistic approach to     semi-supervised learning. Advances in Neural Information Processing     Systems, (pp. 5050-5060). -   Bossard, L., Guillaumin, M., & Van Gool, L. (2014). Food-101—mining     discriminative components with random forests. European conference     on computer vision, (pp. 446-461). -   Chen, T., Sun, Y., Shi, Y., & Hong, L. (2017). On sampling     strategies for neural network-based collaborative filtering.     Proceedings of the 23rd ACM SIGKDD International Conference on     Knowledge Discovery and Data Mining, (pp. 767-776). -   Cimpoi, M., Maji, S., Kokkinos, I., Mohamed, S., & Vedaldi, A.     (2014). Describing textures in the wild. IEEE Conference on Computer     Vision and Pattern Recognition (CVPR), (pp. 3606-3613). -   Cubuk, E. D., Zoph, B., Mane, D., Vasudevan, V., & Le, Q. V. (2019).     Autoaugment: Learning augmentation strategies from data. Proceedings     of the IEEE conference on computer vision and pattern recognition,     (pp. 113-123). -   de Sa, V. R. (1994). Learning classification with unlabeled data.     Advances in neural information processing systems, (pp. 112-119). -   Devlin, J., Chang, M.-W., Lee, K., & Toutanova, K. (2018). Bert:     Pre-training of deep bidirectional transformers for language     understanding. arXiv preprint arXiv:1810.04805. -   DeVries, T., & Taylor, G. W. (2017). Improved regularization of     convolutional neural networks with cutout. arXiv preprint     arXiv:1708.04552. -   Doersch, C., Gupta, A., & Efros, A. A. (2015). Unsupervised visual     representation learning by context prediction. Proceedings of the     IEEE International Conference on Computer Vision, (pp. 1422-1430). -   Donahue, J., & Simonyan, K. (2019). Large scale adversarial     representation learning. Advances in Neural Information Processing     Systems, (pp. 10541-10551). -   Donahue, J., Jia, Y., Vinyals, O., Hoffman, J., Zhang, N., Tzeng,     E., & Darrell, T. (2014). Decaf: A deep convolutional activation     feature for generic visual recognition. International Conference on     Machine Learning, (pp. 647-655). -   Donahue, J., Krähenbühl, P., & Darrell, T. (2016). Adversarial     feature learning. arXiv preprint arXiv:1605.09782. -   Dosovitskiy, A., Springenberg, J. T., Riedmiller, M., & Brox, T.     (2014). Discriminative unsupervised feature learning with     convolutional neural networks. Advances in neural information     processing systems, (pp. 766-774). -   Everingham, M., Van Gool, L., Williams, C. K., Winn, J., &     Zisserman, A. (2010). The Pascal Visual Object Classes (VOC)     challenge. International Journal of Computer Vision, 88, 303-338. -   Fei-Fei, L., Fergus, R., & Perona, P. (2004). Learning generative     visual models from few training examples: An incremental bayesian     approach tested on 101 object categories. IEEE Conference on     Computer Vision and Pattern Recognition (CVPR) Workshop on     Generative-Model Based Vision. -   Gidaris, S., Singh, P., & Komodakis, N. (2018). Unsupervised     representation learning by predicting image rotations. arXiv     preprint arXiv:1803.07728. -   Goodfellow, I., Pouget-Abadie, J., Mirza, M., Xu, B., Warde-Farley,     D., Ozair, S., . . . Bengio, Y. (2014). Generative adversarial nets.     Advances in neural information processing systems, (pp. 2672-2680).

Goyal, P., Dollar, P., Girshick, R., Noordhuis, P., Wesolowski, L., Kyrola, A., . . . He, K. (2017). Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677.

-   Goyal, P., Mahajan, D., Gupta, A., & Misra, I. (2019). Scaling and     benchmarking self-supervised visual representation learning.     Proceedings of the IEEE International Conference on Computer Vision,     (pp. 6391-6400). -   Gross, S., & Wilber, M. (2016). Training and investigating Residual     Nets. The Torch Blog. http://torch.ch/blog/2016/02/04/resnets.html. -   Gutmann, M., & Hyvärinen, A. (2010). Noise-contrastive estimation: A     new estimation principle for unnormalized statistical models.     Proceedings of the Thirteenth International Conference on Artificial     Intelligence and Statistics, (pp. 297-304). -   Hadsell, R., Chopra, S., & LeCun, Y. (2006). Dimensionality     reduction by learning an invariant mapping. 2006 IEEE Computer     Society Conference on Computer Vision and Pattern Recognition (CVPR     '06), 2, pp. 1735-1742. -   Hamilton, W., Ying, Z., & Leskovec, J. (2017). Inductive     representation learning on large graphs. Advances in neural     information processing systems, (pp. 1024-1034). -   He, K., Fan, H., Wu, Y., Xie, S., & Girshick, R. (2019). Momentum     contrast for unsupervised visual representation learning. arXiv     preprint arXiv:1911.05722. -   He, K., Girshick, R., & Dollar, P. (2019). Rethinking ImageNet     pre-training. Proceedings of the IEEE International Conference on     Computer Vision, (pp. 4918-4927). -   He, K., Zhang, X., Ren, S., & Sun, J. (2016). Deep residual learning     for image recognition. Proceedings of the IEEE conference on     computer vision and pattern recognition, (pp. 770-778). -   Hénaff, O. J., Razavi, A., Doersch, C., Eslami, S. M., & Oord, A. v.     (2019). Data-efficient image recognition with contrastive predictive     coding. arXiv preprint arXiv:1905.09272. -   Hinton, G. E., Osindero, S., & Teh, Y.-W. (2006). A fast learning     algorithm for deep belief nets. Neural computation, 18, 1527-1554. -   Hjelm, R. D., Fedorov, A., Lavoie-Marchildon, S., Grewal, K.,     Bachman, P., Trischler, A., & Bengio, Y. (2018). Learning deep     representations by mutual information estimation and maximization.     arXiv preprint arXiv:1808.06670. -   Howard, A. G. (2013). Some improvements on deep convolutional neural     network based image classification. arXiv preprint arXiv:1312.5402. -   Ioffe, S., & Szegedy, C. (2015). Batch normalization: Accelerating     deep network training by reducing internal covariate shift. arXiv     preprint arXiv:1502.03167. -   Ji, X., Henriques, J. F., & Vedaldi, A. (2019). Invariant     information clustering for unsupervised image classification and     segmentation. Proceedings of the IEEE International Conference on     Computer Vision, (pp. 9865-9874). -   Kingma, D. P., & Welling, M. (2013). Auto-encoding variational     bayes. arXiv preprint arXiv: 1312.6114. -   Kolesnikov, A., Beyer, L., Zhai, X., Puigcerver, J., Yung, J.,     Gelly, S., & Houlsby, N. (2019). Large Scale Learning of General     Visual Representations for Transfer. arXiv preprint     arXiv:1912.11370. -   Kolesnikov, A., Zhai, X., & Beyer, L. (2019). Revisiting     self-supervised visual representation learning. Proceedings of the     IEEE conference on Computer Vision and Pattern Recognition, (pp.     1920-1929). -   Kornblith, S., Shlens, J., & Le, Q. V. (2019). Do better ImageNet     models transfer better? Proceedings of the IEEE conference on     computer vision and pattern recognition, (pp. 2661-2671). -   Krause, J., Deng, J., Stark, M., & Fei-Fei, L. (2013). Collecting a     large-scale dataset of fine-grained cars. Second Workshop on     Fine-Grained Visual Categorization. -   Krizhevsky, A., & Hinton, G. (2009). Learning Multiple Layers of     Features from Tiny Images. Tech. rep., University of Toronto.     Retrieved from     https://www.cs.toronto.edu/kriz/learning-features-2009-TR.pdf -   Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). Imagenet     classification with deep convolutional neural networks. Advances in     neural information processing systems, (pp. 1097-1105). -   Linsker, R. (1988). Self-organization in a perceptual network.     Computer, 21, 105-117. -   Loshchilov, I., & Hutter, F. (2016). Sgdr: Stochastic gradient     descent with warm restarts. arXiv preprint arXiv:1608.03983. -   Loshchilov, I., & Hutter, F. (2019). Decoupled Weight Decay     Regularization. International Conference on Learning     Representations. Retrieved from     https://openreview.net/forum?id=Bkg6RiCqY7

Maaten, L. v., & Hinton, G. (2008). Visualizing data using t-SNE. Journal of machine learning research, 9, 2579-2605.

-   Maji, S., Kannala, J., Rahtu, E., Blaschko, M., & Vedaldi, A.     (2013). Fine-Grained Visual Classification of Aircraft. Tech. rep. -   Mikolov, T., Chen, K., Corrado, G., & Dean, J. (2013). Efficient     estimation of word representations in vector space. arXiv preprint     arXiv:1301.3781. -   Misra, I., & van der Maaten, L. (2019). Self-supervised learning of     pretext-invariant representations. arXiv preprint arXiv:1912.01991. -   Nilsback, M.-E., & Zisserman, A. (2008). Automated flower     classification over a large number of classes. Computer Vision,     Graphics & Image Processing, 2008. ICVGIP '08. Sixth Indian     Conference on, (pp. 722-729). -   Noroozi, M., & Favaro, P. (2016). Unsupervised learning of visual     representations by solving jigsaw puzzles. European Conference on     Computer Vision, (pp. 69-84). -   Oord, A. v., Li, Y., & Vinyals, O. (2018). Representation learning     with contrastive predictive coding. arXiv preprint arXiv:1807.03748. -   Parkhi, O. M., Vedaldi, A., Zisserman, A., & Jawahar, C. V. (2012).     Cats and dogs. IEEE Conference on Computer Vision and Pattern     Recognition (CVPR), (pp. 3498-3505). -   Rendle, S., Freudenthaler, C., Gantner, Z., & Schmidt-Thieme, L.     (2012). BPR: Bayesian personalized ranking from implicit feedback.     arXiv preprint arXiv:1205.2618. -   Russakovsky, O., Deng, J., Su, H., Krause, J., Satheesh, S., Ma, S.,     . . . others. (2015). Imagenet large scale visual recognition     challenge. International journal of computer vision, 115, 211-252. -   Schroff, F., Kalenichenko, D., & Philbin, J. (2015). Facenet: A     unified embedding for face recognition and clustering. Proceedings     of the IEEE conference on computer vision and pattern recognition,     (pp. 815-823). -   Simonyan, K., & Zisserman, A. (2014). Very deep convolutional     networks for large-scale image recognition. arXiv preprint     arXiv:1409.1556. -   Sohn, K. (2016). Improved deep metric learning with multi-class     n-pair loss objective. Advances in neural information processing     systems, (pp. 1857-1865). -   Sohn, K., Berthelot, D., Li, C.-L., Zhang, Z., Carlini, N.,     Cubuk, E. D., . . . Raffel, C. (2020). FixMatch: Simplifying     Semi-Supervised Learning with Consistency and Confidence. arXiv     preprint arXiv:2001.07685. -   Szegedy, C., Liu, W., Jia, Y., Sermanet, P., Reed, S., Anguelov, D.,     . . . Rabinovich, A. (2015). Going deeper with convolutions.     Proceedings of the IEEE conference on computer vision and pattern     recognition, (pp. 1-9). -   Tian, Y., Krishnan, D., & Isola, P. (2019). Contrastive multiview     coding. arXiv preprint arXiv:1906.05849. -   Tschannen, M., Djolonga, J., Rubenstein, P. K., Gelly, S., &     Lucic, M. (2019). On mutual information maximization for     representation learning. arXiv preprint arXiv:1907.13625. -   Wu, Z., Xiong, Y., Yu, S. X., & Lin, D. (2018). Unsupervised feature     learning via non-parametric instance discrimination. Proceedings of     the IEEE Conference on Computer Vision and Pattern Recognition, (pp.     3733-3742). -   Xiao, J., Hays, J., Ehinger, K. A., Oliva, A., & Torralba, A.     (2010). SUN database: Large-scale scene recognition from abbey to     zoo. IEEE Conference on Computer Vision and Pattern Recognition     (CVPR), (pp. 3485-3492). -   Xie, Q., Dai, Z., Hovy, E., Luong, M.-T., & Le, Q. V. (2019).     Unsupervised data augmentation. arXiv preprint arXiv:1904.12848. -   Ye, M., Zhang, X., Yuen, P. C., & Chang, S.-F. (2019). Unsupervised     embedding learning via invariant and spreading instance feature.     Proceedings of the IEEE Conference on Computer Vision and Pattern     Recognition, (pp. 6210-6219). -   You, Y., Gitman, I., & Ginsburg, B. (2017). Large batch training of     convolutional networks. arXiv preprint arXiv:1708.03888. -   Zhai, X., Oliver, A., Kolesnikov, A., & Beyer, L. (2019, 10). S4L:     Self-Supervised Semi-Supervised Learning. The IEEE International     Conference on Computer Vision (ICCV). -   Zhang, R., Isola, P., & Efros, A. A. (2016). Colorful image     colorization. European conference on computer vision, (pp. 649-666). -   Zhuang, C., Zhai, A. L., & Yamins, D. (2019). Local aggregation for     unsupervised learning of visual embeddings. Proceedings of the IEEE     International Conference on Computer Vision, (pp. 6002-6012). 

What is claimed is:
 1. A computing system to perform contrastive learning of visual representations, the computing system comprising: one or more processors; and one or more non-transitory computer-readable media that collectively store: a base encoder neural network configured to process an input image to generate an intermediate representation of the input image; a projection head neural network configured to process the intermediate representation of the input image to generate a projected representation of the input image, wherein to generate the projected representation, the projection head neural network is configured to perform at least one non-linear transformation; and instructions that, when executed by the one or more processors, cause the computing system to perform operations, the operations comprising: obtaining a training image; performing a plurality of first augmentation operations on the training image to obtain a first augmented image, wherein the plurality of first augmentation operations comprise at least a first random crop operation that randomly crops the training image and a first random color distortion operation that randomly modifies color values of the training image to the training image; separate from performing the plurality of first augmentation operations, performing a plurality of second augmentation operations on the training image to obtain a second augmented image, wherein the plurality of second augmentation operations comprise at least a second random crop operation that randomly crops the training image and a second random color distortion operation that randomly modifies color values of the training image; respectively processing, with the base encoder neural network, the first augmented image and the second augmented image to respectively generate a first intermediate representation for the first augmented image and a second intermediate representation for the second augmented image; respectively processing, with the projection head neural network, the first intermediate representation and the second intermediate representation to respectively obtain a first projected representation for the first augmented image and a second projected representation for the second augmented image; evaluating a loss function that evaluates a difference between the first projected representation and the second projected representation; and modifying one or more values of one or more parameters of one or both of the base encoder neural network and the projection head neural network based at least in part on the loss function.
 2. The computing system of claim 1, wherein the plurality of first augmentation operations further comprises a first resize operation that resizes the training image and wherein the plurality of second augmentation operations further comprises a second resize operation that resizes the training image.
 3. The computing system of claim 1, wherein the plurality of first augmentation operations further comprises a first random flip operation that randomly flips the training image and wherein the plurality of second augmentation operations further comprises a second random flip operation that randomly flips the training image.
 4. The computing system of claim 1, wherein the first random color distortion operation and the second random color distortion operation have a color distortion strength of at least one half.
 5. The computing system of claim 4, wherein the first random color distortion operation and the second color distortion operation have a color distortion strength of one.
 6. The computing system of claim 1, wherein the plurality of first augmentation operations further comprises a first random Gaussian blur operation that randomly applies a Gaussian blur to the training image and wherein the plurality of second augmentation operations further comprises a second random Gaussian blur operation that randomly applies a Gaussian blur to the training image.
 7. The computing system of claim 1, wherein the base encoder neural network comprises a ResNet convolutional neural network, and wherein the intermediate representation comprises an output of a final average pooling layer of the ResNet convolutional neural network.
 8. The computing system of claim 1, wherein the projection head neural network comprises a multi-layer perceptron that comprises one hidden layer and a rectified linear unit non-linear activation function.
 9. The computing system of claim 1, wherein the loss function comprises an L2 normalized cross entropy loss with an adjustable temperature parameter.
 10. The computing system of claim 9, wherein the adjustable temperature parameter has a value equal to or greater than 0.1 and equal to or less than 0.5.
 11. The computing system of claim 1, wherein the operations further comprise performing the operations described in claim 1 across a training batch of training images, wherein the training batch of training images comprises at least 256 training images.
 12. The computing system of claim 11, wherein the training batch comprises greater than 2000 training images.
 13. The computing system of claim 12, wherein the training batch comprises greater than 4000 training images.
 14. The computing system of claim 11, wherein the operations further comprise performing learning rate scaling based on a number of training images included in the training batch.
 15. The computing system of claim 1, The computing system of claim 1, wherein the operations further comprise performing the operations described in claim 1 for at least 1000 epochs.
 16. The computing system of claim 1, wherein evaluating the loss function comprises evaluating the loss function based only on in-batch negative example sampling, whereby an instance class representation vector is not required to be stored in a memory bank.
 17. The computing system of claim 1, wherein evaluating the loss function comprises performing global batch normalization to aggregate mean and variance over a plurality of different devices.
 18. A computer-implemented method to perform contrastive learning of visual representations, method comprising: obtaining a training image; performing a plurality of first augmentation operations on the training image to obtain a first augmented image, wherein the plurality of first augmentation operations comprise at least a first random crop operation that randomly crops the training image and a first random color distortion operation that randomly modifies color values of the training image to the training image; separate from performing the plurality of first augmentation operations, performing a plurality of second augmentation operations on the training image to obtain a second augmented image, wherein the plurality of second augmentation operations comprise at least a second random crop operation that randomly crops the training image and a second random color distortion operation that randomly modifies color values of the training image; respectively processing, with a base encoder neural network, the first augmented image and the second augmented image to respectively generate a first intermediate representation for the first augmented image and a second intermediate representation for the second augmented image; respectively processing, with a projection head neural network, the first intermediate representation and the second intermediate representation to respectively generate a first projected representation for the first augmented image and a second projected representation for the second augmented image; evaluating a loss function that evaluates a difference between the first projected representation and the second projected representation; and modifying one or more values of one or more parameters of one or both of the base encoder neural network and the projection head neural network based at least in part on the loss function.
 19. The computer-implemented method of claim 18, wherein the loss function comprises an L2 normalized cross entropy loss with an adjustable temperature parameter.
 20. One or more non-transitory computer-readable media that collectively store a base encoder neural network that has been trained by a training method, the training method comprising: obtaining a training image; performing a plurality of first augmentation operations on the training image to obtain a first augmented image, wherein the plurality of first augmentation operations comprise at least a first random crop operation that randomly crops the training image and a first random color distortion operation that randomly modifies color values of the training image to the training image; separate from performing the plurality of first augmentation operations, performing a plurality of second augmentation operations on the training image to obtain a second augmented image, wherein the plurality of second augmentation operations comprise at least a second random crop operation that randomly crops the training image and a second random color distortion operation that randomly modifies color values of the training image; respectively processing, with the base encoder neural network, the first augmented image and the second augmented image to respectively generate a first intermediate representation for the first augmented image and a second intermediate representation for the second augmented image; respectively processing, with a projection head neural network, the first intermediate representation and the second intermediate representation to respectively generate a first projected representation for the first augmented image and a second projected representation for the second augmented image; evaluating a loss function that evaluates a difference between the first projected representation and the second projected representation; and modifying one or more values of one or more parameters of the base encoder neural network based at least in part on the loss function. 